Authenticating User and Launching an Application on a Single Intentional User Gesture

ABSTRACT

Methods, systems, and apparatus, including computer programs encoded on computer storage media, for combining authentication and application shortcut. An example method includes detecting, by a device having a touchscreen, a gesture by a user on the touchscreen while the device is in a sleep mode; classifying the gesture, by the device, as an intentional gesture or an accidental gesture; maintaining the device in the sleep mode if the gesture is classified as an accidental gesture; responsive to determining, by the device, that the gesture matches one or more confirmed gestures stored on the device based at least in part on a set of predefined criteria, if the gesture is classified as an intentional gesture: recognizing the user as authenticated; and without requiring additional user input, selecting an application, from a plurality of different applications, according to the gesture and launching the application on the device.

TECHNICAL FIELD

This specification relates to authenticating users and launchingapplications on devices with gesture-based user interfaces.

BACKGROUND

User authentication and application launching are often implemented asseparate processes, each requiring different user inputs. Also, everytime a user attempts an authentication on a device, the device needs tobe activated from a sleep or standby mode, which will consume power.

SUMMARY

In general, this specification describes techniques for authenticating auser and launching a user-selected application in response to and inaccordance with a single intentional user gesture.

In general, one innovative aspect of the subject matter described inthis specification can be embodied in methods that include the actionsof detecting, by a device having a touchscreen, a gesture by a user onthe touchscreen while the device is in a sleep mode; classifying thegesture, by the device, as an intentional gesture or an accidentalgesture; maintaining the device in the sleep mode if the gesture isclassified as an accidental gesture; responsive to determining, by thedevice, that the gesture matches one or more confirmed gestures storedon the device based at least in part on a set of predefined criteria, ifthe gesture is classified as an intentional gesture: recognizing theuser as authenticated; and without requiring additional user input,selecting an application, from a plurality of different applications,according to the gesture and launching the application on the device.

Other embodiments of this aspect include corresponding computingsystems, apparatus, and computer programs recorded on one or morecomputing storage devices, each configured to perform the actions of themethods. For a system of one or more computers to be configured toperform particular operations or actions means that the system hasinstalled on it software, firmware, hardware, or a combination of themthat in operation cause the system to perform the operations or actions.For one or more computer programs to be configured to perform particularoperations or actions means that the one or more programs includeinstructions that, when executed by data processing apparatus, cause theapparatus to perform the operations or actions.

Particular embodiments of the subject matter described in thisspecification can be implemented so as to realize one or more of thefollowing advantages. Power consumption may be reduced: a user deviceremains in a sleep mode, which consumes less power compared to an activemode, when only accidental gestures are detected. User input required tosecurely launch an application may be reduced: a single user gesture cansuffice to not only authenticate a user, but also launch a user-selectedapplication.

The details of one or more embodiments of the subject matter of thisspecification are set forth in the accompanying drawings and thedescription below. Other features, aspects, and advantages of thesubject matter will become apparent from the description, the drawings,and the claims.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram illustrating an example process forauthenticating a user and launching a user-selected applicationresponsive to a single intentional user gesture.

FIG. 2 is a flow diagram illustrating an example process for detectingand disregarding accidental gestures, as well as authenticating a userand launching an application responsive to a single intentional gesture.

FIG. 3 is a flow diagram illustrating an example process for detectingand disregarding accidental gestures based on predefined criteria.

FIG. 4 is a block diagram of an example device.

Like reference numbers and designations in the various drawings indicatelike elements.

DETAILED DESCRIPTION

The implementations described in this specification provide varioustechnical solutions to combine user authentication and applicationselection shortcuts in accordance with a single intentional user gestureby (1) detecting and disregarding accidental user gestures on a device'stouchscreen without transitioning the device from a reduced powerconsumption mode, e.g., a sleep mode, into an increased powerconsumption mode, e.g., an active mode, and (2) securely launching anapplication on the device upon detecting an intentional user gesturethat matches a predefined user gesture.

For example, a smartphone can maintain a gesture detection component,e.g., a software module, a hardware unit, or a combination of both, inan active detection mode, but other more power-consuming components,e.g., the touchscreen, the processor, and the main memory, in a sleep orstandby mode.

When a user swipes two fingers across the smartphone's touchscreen, thegesture detection component classifies—without activating the other morepower-consuming components from the sleep mode—this two-finger swipegesture as either an intentional user gesture or an accidental gesture.For example, the gesture detection component tries to determine whetherthe user making the two-finger swipe gesture is trying to unlock thesmartphone and launch a map application or whether the user hasaccidentally swiped her fingers on the touchscreen while grabbing thesmartphone.

In some cases, the gesture detection component makes this classificationbased on a set of predefined criteria, e.g., the orientation of thesmartphone when the swipe occurred, the movement speed or accelerationof the smartphone when the swipe occurred, and the total number offingers involved in making the swipe.

For instance, if the smartphone was placed upside down when the swipeoccurred, then it is more likely that the swipe was accidental, based onthe assumption that a user is more likely to make intentional gesturewhen a device is in an upright position. For another instance, if thesmartphone was moving at an eight-mile per hour speed when the swipeoccurred, then it is more likely that the swipe was accidental, based onthe assumption that a user is more likely to make intentional gestureswhen keeping a device still. For a third instance, if the swipe was madewith four fingers, then it is more likely that the swipe was accidental,based on the assumption that a user is more likely to make intentionalgestures using two or fewer fingers, given the size of the touchscreenrelative to that of the user's fingers.

Based on one or more of these predefined criteria, if the gesturedetection component classifies the user's two-finger swipe on thetouchscreen as accidental, the gesture detection component disregardsthe swipe gesture without activating some of the smartphone componentsthat are in a sleep mode, to keep the power consumption low.

If, however, the gesture detection component classifies the user'stwo-finger swipe as intentional, the gesture detection componentactivates other smartphone components on an as-needed basis.

For example, upon detecting an intentional gesture, the gesturedetection component, in some cases, activate a gesture-basedauthentication component from the sleep mode, which can furtherdetermine whether to unlock the smartphone based on the two-fingerswipe. If the authentication is successful, the gesture detectioncomponent in some cases next activates an application launchingcomponent from the sleep mode, which then determines which one of theseveral different applications resident on the smartphone may belaunched based on the two-finger swipe.

The gesture-based authentication component, in some cases, unlocks thesmartphone if the two-finger swipe matches a user gesture that has beenconfirmed as sufficient to unlock the smartphone, e.g., unlocking thesmartphone after detecting an “L” shape gesture using 2 fingers.

The application launching component, in some cases, selectively launchesan application, among several different applications, if the two-fingerswipe matches a user gesture that has been confirmed as a shortcut tolaunch the application, e.g., launching an email application, e.g., asopposed to a map application, after detecting an “L” shape gesture usingtwo fingers.

In these ways, added user convenience is provided and power consumptionmaintained low: because a user is not required to provide separateinputs for authentication and application launching; and smartphonecomponents are kept in sleep mode and selectively activated on anas-needed basis.

These technical solutions may be particularly advantageous whenimplemented on mobile devices, e.g., smartphones or tablet computers,where power consumption is a more prominent issue and userauthentications are more frequently attempted.

FIG. 1 is a block diagram illustrating an example process 100 for userauthentication and application launching in response to a singleintentional user gesture.

The process begins with a device 102 in a sleep or standby mode (110).

The device is locked when in the sleep mode and requires a successfuluser authentication to unlock. For example, a user may need to providepasscode, fingerprint identification, voice verification, or touchscreengesture, in order to access the device.

In some implementations, a device or a component within the deviceconsumes less power when placed in the sleep mode. For example, when adevice 102 is in a sleep mode, a processor in the device 102 is placedin an idle mode or the device's display or touchscreen is dimmed orturned off.

A gesture detection component within the device 102 is maintained in anactive mode to detect user gesture on the device's touchscreen, whilesome other components of the device 102 is in a sleep mode. In someimplementations, the gesture detection component is implemented as a lowpower consumption digital signal processor (DSP). In otherimplementations, the gesture detection component is implemented as asoftware program, e.g., a touchscreen driver program, running in thebackground while the device's touchscreen is dimmed.

Based on a set of predefined criteria, the gesture detection componentsometimes classifies a gesture detected on the touchscreen of the device102 as an accidental gesture 112.

The gesture detection component does not activate the device into anactive mode, after detecting an accidental gesture. In someimplementations, when activated, a device or a device component isplaced on an increased power consumption level.

Techniques for classifying a user gesture as an intentional user gestureor an accidental user gesture are described in more detail in referenceto FIG. 2 and FIG. 3.

If the gesture detection component classifies a gesture as anintentional gesture 152, the gesture detection component activates anauthentication component of the device from the sleep mode.

If the authentication component recognizes one or more characteristics,e.g., shape, speed, or location, of the intentional gesture 152 and,based on these characteristics, compares the gesture 152 with a set ofconfirmed gestures, the device can determine whether the user providingthe gesture can be authenticated on the device 102.

If the authentication component determines that the user can beauthenticated on the device, it unlocks the device 102.

In some implementations, as part of a successful authentication, theauthentication component also activates an application launchingcomponent from the sleep mode.

In some other implementations, as part of a successful authentication,the authentication component optionally activates one or more additionalcomponents of the device from the sleep mode into the active mode, e.g.,increasing the brightness of the touchscreen and placing the processorin a working mode from an idle mode to enable faster processing of usertasks.

Based on one or more recognized characteristics, e.g., shape, speed, orlocation, of the intentional gesture 152, the application launchingcomponent selectively launches one or more applications, from a set ofdifferent applications. For example, based on the shape of theintentional gesture 152, the application launching component launches anemail application 182 rather than a map application.

Note that these actions do not require additional user input, other thanthe intentional gesture 152. These techniques can be advantageous, as asingle intentional gesture suffices to both authenticate a user on thedevice and launch an application as predefined by the user.

FIG. 2 is a flow diagram illustrating an example process 200 fordetecting and disregarding accidental gestures, as well asauthenticating a user and launching an application in response to and inaccordance with a single intentional gesture.

For convenience, the process 200 will be described as being performed bya device having a touch screen, one or more processors, and memory forstoring executable instruction for execution by the one or moreprocessors. For example, the device 400 shown in FIG. 4, appropriatelyprogrammed in accordance with this specification, can perform theprocess 200.

The device detects a gesture by a user on the touchscreen while thecomputing device is in a sleep mode (step 202). The computing device canbe, e.g., a smartphone, a tablet computer, or a desktop or notebookcomputer, with a touchscreen.

In some implementations, the device maintains a blank screen on itstouchscreen when detecting user gestures, e.g., to reduce powerconsumption. Maintaining a blank screen may be particularly advantageouswhen accidental gestures frequently occur.

In some other implementations, when in sleep mode, the device providesone or more visual aids to facilitate gesturing on the touchscreen. Forexample, the device, without transitioning the touchscreen into a fullylit mode, may display a gesture trail to guide the user to complete theinstant gesture or additional gestures. These visual feedbacks from thedevice inform a user not only that the device is in a working mode, butalso what gesture it has detected.

After detecting the gesture, the computing device next determineswhether to classify the gesture as an accidental gesture or as anintentional gesture (step 204). The computing device can make thisdetermination by comparing the gesture against a set of predefinedcriteria.

If the device classifies the gesture as an accidental user gesture 205,the device disregards the gesture (step 208) and maintains or returns tothe sleep mode. The set of predefined criteria may include, for example,one or more characteristics associated with the gesture or the device.

In some cases, when in or maintaining a sleep mode, the device maintainsa blank screen on the touchscreen and one or more components of thecomputing device other than the touchscreen in a reduce powerconsumption mode, e.g., an idle mode.

If the gesture is classified as an intentional user gesture (205) andthe process 200 continues to the authentication step (step 206).

The device authenticates the user on the computing device by matchingthe intentional gesture to one or more confirmed gestures (step 206).

In some implementations, the intentional user gesture identifies analphanumeric character, e.g., a letter “B” or a number “4.” In someimplementations, the device matches an alphanumeric gesture againstpredefined alphanumeric values using a pre-trained handwritingrecognition module that recognize whether handwriting embodied in analphanumeric gesture matches handwritings of an authenticated user.

In some implementations, the intentional user gesture identifies apredefined shape, e.g., a triangle shape or a circle shape. In someimplementations, the device matches shape gestures against a set ofpredefined shape gesture templates, which an authenticated user cancustomize.

In some implementations, authenticating a user on a device includesdetermining whether to unlock the device in accordance with one or moreinputs, e.g., a finger gesture, a manually entered passcode, or a voiceidentification, provided by the user. For example, if a user hasgestured a letter “B” on a smartphone's touchscreen and the letter “B”is one of the confirmed gestures stored on the smartphone, thesmartphone unlocks to allow user access. Otherwise, the device remainslocks and the device may offer alternative authentication means to theuser.

If an authentication is successful, the device, without requiringadditional user input, places the computing device in an active mode(step 212).

Upon a successful authentication, the device, without requiringadditional user input, also selects an application, from a plurality ofdifferent applications, according to the gesture, and launches theapplication on the device (step 214). For example, based on the sameletter “B” gesture, the smartphone searches against agesture-application mapping table that maps user gestures touser-designated applications, and determines that the letter “B” gestureidentifies a particular application, which the devices next launches.

In some implementations, after launching an application, the deviceautomatically provides input to the application based on the detectedintentional user gesture. In other words, the single intentional usergesture detected not only serves authentication and application shortcutpurposes, but also serves as an input to an application launched at thestep 214. In some implementations, if the intentional user gesturematches a predefined shape, e.g., a rectangle shape or a triangle shape,the process 200 optionally includes selecting the application, from aplurality of different applications, in accordance with the predefinedshape. For example, based on a triangle-shape gesture, the smartphonesearches against a gesture-application table that maps user gestures todesignated applications, and determines that the triangle-shape gestureidentifies a map application on the smartphone, and launches the mapapplication without requiring the user to provide any additional inputsas to which application to launch.

In some implementations, when a gesture-based authentication fails, thedevice provides an alternative authentication means (step 210). Forexample, when the computing device determines that an intentional usergesture is insufficient to authenticate a user, the computing devicepromotes the user to manually provide a password or a fingerprint, andattempts to authenticate the user based on these inputs (step 216).

In some cases where a gesture-based authentication fails, the devicereuses information identified in the single intentional gesture forfurther authentication, reducing the total amount of user input requiredfor further authentications.

For example, when a smartphone obtains, from a user, a number “4”gesture, but determines that the number “4” gesture (e.g., alone) doesnot suffice to authenticate the user, the smartphone provides apassword-based authentication that requires a 2-digit passcode, andprovides the number “4” as the first digit of the 2-digit passcode.These techniques are advantageous, as required user inputs are reduced,even in an event of an unsuccessful gesture-based authentication.

In some implementations, the devices enables gesturing in an alternativeauthentication means.

For example, after invoking a password-based alternative authentication,the device continues to accept user gesture and provides correspondinginput (e.g., symbols or numbers) to the password-based authentication.To continue with the above example, after providing the number “4” asthe first digit of the 4-digit passcode, the smartphone detects agesture having a number “6” shape and accordingly provides the number“6” as the second digit of the 2-digit passcode. The smartphone cancontinue the password-based authentication by attempting to authenticatethe user based on the 2-digit passcode “46.”

In some implementations, the devices reuses information capture in agesture in an alternative authentication means.

For another example, after invoking a fingerprint-based alternativeauthentication, the computing device reuses a fingerprint characteristicincluded in the detected intentional user gesture and provides thefingerprint characteristic to the fingerprint-based alternativeauthentication. For example, if a gesture includes a pattern (e.g.,arch, loop, and whorl) of a user's index finger, the computing devicecan capture and provide the characteristic as part of the input to thefingerprint authentication.

An authenticated user can customize gestures for user authentication andapplication launching. For example, a user may designate a “B” shapegesture as sufficient to unlock a smartphone and launching an email appon the smartphone. In these ways, an authenticated user can modifyconfirmed gestures or symbols stored on a mobile device, which in turnmodifies subsequent gesture-based authentication process and applicationlaunching process.

FIG. 3 is a flow diagram illustrating an example process 300 fordetecting and disregarding accidental gesture based on predefinedcriteria.

For convenience, the process 300 will be described as being performed bya computing device having one or more processors and memory for storingexecutable instruction for execution by the one or more processors. Forexample, the device 400 shown in FIG. 4, appropriately programmed inaccordance with this specification, can perform the process 300.

In some cases, to determine whether a detected user gesture is anaccidental gesture or an intentional gesture, a device identifies afirst characteristic associated with a user gesture (step 302) andoptionally a second characteristic associated with a device (step 304).

In some cases, the device 300 analyzes one or more of the followingcharacteristics associated with a user gesture: the number of touchesincluded in the gesture, the type of the gesture (e.g., swipe, release,and release), the on-touchscreen locations where the gestureoccurred/covered, the acceleration magnitude of the gesture, the size(e.g., in terms of the number of pixels) of the gesture, the amount ofpressure exerted on the touchscreen by the gesture, the distance andwidth covered by the gesture, the duration of the gesture, the number ofsimultaneous finger-touches included in the gesture, and if the gestureincludes multiple strokes, the proximity of two (e.g., consecutive)strokes,

In some cases, the device optionally analyzes one or more of thefollowing the characteristics associated with the computing device whena user gesture is detected: the computing device's orientation, thecomputing device's tilt angle (e.g., vertically or horizontally), thecomputing device's speed of movement, and the computing device'sacceleration magnitude.

Based on one or more of these gesture- and device-relatedcharacteristics, the device then determines whether the user gesture isan intentional gesture (step 306). For example, the computing devicedetermines the likelihood (L) of a gesture being an intentional gestureby assigning a weight (Wi, e.g., ranging from 0 to 1) to each of theanalyzed characteristics (Ci, e.g., with values normalized ranging from0 to 1) and calculating a weighted total L. In some implementations,L=Total over i of (Wi×Ci), where i=1 to the total number ofcharacteristics analyzed. In some cases, the device classifies a gesturehaving a weighted total L equal to or more than a predefined value, asan intentional gesture and every other gesture as an accidental gesture.

After classifying a detected gesture as an intentional gesture, thedevice attempts to authenticate the user providing the gesture based onone or more characteristics associated with the gesture.

In some implementations, a user authentication process includescalculating the probability (P(u(g)) that a user providing the gestureis an authorized user as identified by a confirmed gesture stored on thecomputing device as follows:

${P\left( {{{u()} = {u^{*}}},G^{*}} \right)} = {\sum\limits_{s \in S}{{P\left( {{{u()} = {u^{*}}},s,G^{*}} \right)}{{P\left( {s} \right)}.}}}$

Here, S represents a set of symbols (e.g., “4”; “A”; “a”; “×”; and “

”); G represents the set of confirmed gestures (provided by one or moreauthenticated users) identifying the set of symbols; and P (s|g) iscalculated using a user-independent gesture recognition module, e.g., ahandwriting recognition module.

In some implementations, the probability (P (u(g)) is calculated asfollows:

P(u(g)=u*|g,G*)=max_(g) _(i) _(εG) _(s) _(*) P(u(g)=u(g _(i))|s)

Here,

P(u(g)=u(g _(i))|s)

is the probability that two gestures identifying a same symbol (e.g.,“4”; “A”; “a”; “×”; and “

”) are provided by a same user.

FIG. 4 is a block diagram of an example computing device 400. The userauthentication and application launching technologies described in thisspecification can be implemented on the computing device 400.

The device 400 typically includes one or more processing units CPU(s)402 (also referred to as processors), one or more network interfaces404, memory 406, and one or more communication buses 408 forinterconnecting these components. The communication buses 408 optionallyinclude circuitry (sometimes called a chipset) that interconnects andcontrols communications between system components. The memory 406includes high-speed random access memory, such as DRAM, SRAM, DDR RAM orother random access solid state memory devices; and optionally includesnon-volatile memory, such as one or more magnetic disk storage devices,optical disk storage devices, flash memory devices, or othernon-volatile solid state storage devices. The memory 406 optionallyincludes one or more storage devices remotely located from CPU(s) 402.The memory 406, or alternatively the non-volatile memory device(s)within the memory 406, comprises a non-transitory computer readablestorage medium. In some implementations, the memory 406 or alternativelythe non-transitory computer readable storage medium stores the followingprograms, modules and data structures, or a subset thereof:

-   -   an operating system 410, which includes procedures for handling        various basic system services and for performing hardware        dependent tasks;    -   a network communication module (or instructions) 412 for        connecting the device 400 with other devices (e.g., one or more        server computers) via the one or more network interfaces 404        (wired or wireless);    -   a gesture detection module 416 for detecting user gestures on        the touchscreen 405 and classifying a detected user gesture as        either an accidental gesture or an intentional gesture;    -   an authentication module 418 for authenticating a user on the        device 400 (e.g., unlocking the device) in accordance with a        detected intentional user gesture;    -   an application launching module 418 for selecting, among several        different applications, an application in accordance with a        detected intentional user gesture and launching the application        on the device; and    -   data 420 stored on the device, which include:        -   one or more confirmed gestures 422, e.g., a two-finger            gesture having a letter “B” shape or a single-finger gesture            having a number “4” shape; and        -   a set of different applications 426, such as an email            application 428-1 and a chat application 428-2.

In some implementations, the gesture detection module 414 maintains thetouchscreen 405 in an active mode to detect user gestures, when othercomponents of device 400 (e.g., the authentication module 416 and theapplication launching module 418) are in a sleep or standby model. Insome implementations, unless a successful authentication occurs, thegesture detection module 414 maintains the touchscreen 405 in a blankscreen mode, e.g., to consume less power.

In some implementations, one or more of the above identified elementsare stored in one or more of the previously mentioned memory devices,and correspond to a set of instructions for performing a functiondescribed above. The above identified modules or programs (e.g., sets ofinstructions) need not be implemented as separate software programs,procedures or modules, and thus various subsets of these modules may becombined or otherwise re-arranged in various implementations. In someimplementations, the memory 306 optionally stores a subset of themodules and data structures identified above. Furthermore, the memory306 may store additional modules and data structures not describedabove.

Embodiments of the subject matter and the functional operationsdescribed in this specification can be implemented in digital electroniccircuitry, in tangibly-embodied computer software or firmware, incomputer hardware, including the structures disclosed in thisspecification and their structural equivalents, or in combinations ofone or more of them. Embodiments of the subject matter described in thisspecification can be implemented as one or more computer programs, i.e.,one or more modules of computer program instructions encoded on atangible non transitory program carrier for execution by, or to controlthe operation of, data processing apparatus. Alternatively or inaddition, the program instructions can be encoded on an artificiallygenerated propagated signal, e.g., a machine-generated electrical,optical, or electromagnetic signal, that is generated to encodeinformation for transmission to suitable receiver apparatus forexecution by a data processing apparatus. The computer storage mediumcan be a machine-readable storage device, a machine-readable storagesubstrate, a random or serial access memory device, or a combination ofone or more of them.

The term “data processing apparatus” encompasses all kinds of apparatus,devices, and machines for processing data, including by way of example aprogrammable processor, a computer, or multiple processors or computers.The apparatus can include special purpose logic circuitry, e.g., an FPGA(field programmable gate array) or an ASIC (application specificintegrated circuit). The apparatus can also include, in addition tohardware, code that creates an execution environment for the computerprogram in question, e.g., code that constitutes processor firmware, aprotocol stack, a database management system, an operating system, or acombination of one or more of them.

A computer program (which may also be referred to or described as aprogram, software, a software application, a module, a software module,a script, or code) can be written in any form of programming language,including compiled or interpreted languages, or declarative orprocedural languages, and it can be deployed in any form, including as astandalone program or as a module, component, subroutine, or other unitsuitable for use in a computing environment. A computer program may, butneed not, correspond to a file in a file system. A program can be storedin a portion of a file that holds other programs or data, e.g., one ormore scripts stored in a markup language document, in a single filededicated to the program in question, or in multiple coordinated files,e.g., files that store one or more modules, sub programs, or portions ofcode. A computer program can be deployed to be executed on one computeror on multiple computers that are located at one site or distributedacross multiple sites and interconnected by a communication network.

The processes and logic flows described in this specification can beperformed by one or more programmable computers executing one or morecomputer programs to perform functions by operating on input data andgenerating output. The processes and logic flows can also be performedby, and apparatus can also be implemented as, special purpose logiccircuitry, e.g., an FPGA (field programmable gate array) or an ASIC(application specific integrated circuit).

Computers suitable for the execution of a computer program include, byway of example, can be based on general or special purposemicroprocessors or both, or any other kind of central processing unit.Generally, a central processing unit will receive instructions and datafrom a read only memory or a random access memory or both. The essentialelements of a computer are a central processing unit for performing orexecuting instructions and one or more memory devices for storinginstructions and data. Generally, a computer will also include, or beoperatively coupled to receive data from or transfer data to, or both,one or more mass storage devices for storing data, e.g., magnetic,magneto optical disks, or optical disks. However, a computer need nothave such devices. Moreover, a computer can be embedded in anotherdevice, e.g., a mobile telephone, a personal digital assistant (PDA), amobile audio or video player, a game console, a Global PositioningSystem (GPS) receiver, or a portable storage device, e.g., a universalserial bus (USB) flash drive, to name just a few.

Computer readable media suitable for storing computer programinstructions and data include all forms of nonvolatile memory, media andmemory devices, including by way of example semiconductor memorydevices, e.g., EPROM, EEPROM, and flash memory devices; magnetic disks,e.g., internal hard disks or removable disks; magneto optical disks; andCD ROM and DVD-ROM disks. The processor and the memory can besupplemented by, or incorporated in, special purpose logic circuitry.

To provide for interaction with a user, embodiments of the subjectmatter described in this specification can be implemented on a computerhaving a display device, e.g., a CRT (cathode ray tube) or LCD (liquidcrystal display) monitor, for displaying information to the user and akeyboard and a pointing device, e.g., a mouse or a trackball, by whichthe user can provide input to the computer. Other kinds of devices canbe used to provide for interaction with a user as well; for example,feedback provided to the user can be any form of sensory feedback, e.g.,visual feedback, auditory feedback, or tactile feedback; and input fromthe user can be received in any form, including acoustic, speech, ortactile input. In addition, a computer can interact with a user bysending documents to and receiving documents from a device that is usedby the user; for example, by sending web pages to a web browser on auser's client device in response to requests received from the webbrowser.

Embodiments of the subject matter described in this specification can beimplemented in a computing system that includes a back end component,e.g., as a data server, or that includes a middleware component, e.g.,an application server, or that includes a front end component, e.g., aclient computer having a graphical user interface or a Web browserthrough which a user can interact with an implementation of the subjectmatter described in this specification, or any combination of one ormore such back end, middleware, or front end components. The componentsof the system can be interconnected by any form or medium of digitaldata communication, e.g., a communication network. Examples ofcommunication networks include a local area network (“LAN”) and a widearea network (“WAN”), e.g., the Internet.

The computing system can include clients and servers. A client andserver are generally remote from each other and typically interactthrough a communication network. The relationship of client and serverarises by virtue of computer programs running on the respectivecomputers and having a client-server relationship to each other.

While this specification contains many specific implementation details,these should not be construed as limitations on the scope of anyinvention or of what may be claimed, but rather as descriptions offeatures that may be specific to particular embodiments of particularinventions. Certain features that are described in this specification inthe context of separate embodiments can also be implemented incombination in a single embodiment. Conversely, various features thatare described in the context of a single embodiment can also beimplemented in multiple embodiments separately or in any suitablesubcombination. Moreover, although features may be described above asacting in certain combinations and even initially claimed as such, oneor more features from a claimed combination can in some cases be excisedfrom the combination, and the claimed combination may be directed to asubcombination or variation of a subcombination.

Similarly, while operations are depicted in the drawings in a particularorder, this should not be understood as requiring that such operationsbe performed in the particular order shown or in sequential order, orthat all illustrated operations be performed, to achieve desirableresults. In certain circumstances, multitasking and parallel processingmay be advantageous. Moreover, the separation of various system modulesand components in the embodiments described above should not beunderstood as requiring such separation in all embodiments, and itshould be understood that the described program components and systemscan generally be integrated together in a single software product orpackaged into multiple software products.

Particular embodiments of the subject matter have been described. Otherembodiments are within the scope of the following claims. For example,the actions recited in the claims can be performed in a different orderand still achieve desirable results. As one example, the processesdepicted in the accompanying figures do not necessarily require theparticular order shown, or sequential order, to achieve desirableresults. In certain implementations, multitasking and parallelprocessing may be advantageous.

What is claimed is:
 1. A method comprising: detecting, by a devicehaving a touchscreen, a first gesture by a user on the touchscreen whilethe device is in a sleep mode; classifying the first gesture, by thedevice, as an intentional gesture or an accidental gesture and either(i) maintaining the device in the sleep mode if the first gesture isclassified as an accidental gesture, or (ii) determining, by the device,whether the first gesture matches one or more confirmed gestures storedon the device if the first gesture is classified as an intentionalgesture; and, if the first gesture is classified as an intentionalgesture, either (i) requiring an additional user input to authenticatethe user if the first gesture does not match one or more confirmedgestures stored on the device, or (ii) recognizing the user asauthenticated and selecting and launching an application from aplurality of applications on the device according to the first gesture,if the first gesture matches one or more confirmed gestures stored onthe device, without requiring any user input in addition to the firstgesture to authenticate the user or select and launch the application.2. (canceled)
 3. (canceled)
 4. The method of claim 1, furthercomprising: identifying the gesture as a drawing of an alphanumericcharacter on the touchscreen, the alphanumeric character having analphanumeric value; and providing the alphanumeric value as an input tothe application.
 5. (canceled)
 6. The method of claim 1, furthercomprising: in accordance with a determination that the gesture isclassified as an intentional gesture and the gesture fails to match oneor more confirmed gestures stored on the device: presenting, to theuser, a password-based authentication mechanism; and requiring the userto input a password. 7-15. (canceled)
 16. A computing device comprising:one or more processors; a touchscreen; and, one or more storage unitsstoring instructions that when executed by the one or more processorscause the computing device to perform operations comprising: detecting,by a device having a touchscreen, a first gesture by a user on thetouchscreen while the device is in a sleep mode; classifying the firstgesture, by the device, as an intentional gesture or an accidentalgesture and either (i) maintaining the device in the sleep mode if thefirst gesture is classified as an accidental gesture, or (ii)determining, by the device, whether the first gesture matches one ormore confirmed gestures stored on the device if the first gesture isclassified as an intentional gesture; and, if the first gesture isclassified as an intentional gesture, either (i) requiring an additionaluser input to authenticate the user if the first gesture does not matchone or more confirmed gestures stored on the device, or (ii) recognizingthe user as authenticated and selecting and launching an applicationfrom a plurality of applications on the device according to the firstgesture, if the first gesture matches one or more confirmed gesturesstored on the device, without requiring any user input in addition tothe first gesture to authenticate the user or select and launch theapplication.
 17. The device of claim 16, wherein the operations furthercomprise identifying the first gesture as a drawing of an alphanumericcharacter on the touchscreen, the alphanumeric character having analphanumeric value.
 18. A non-transitory computer storage medium encodedwith a computer program, the computer program comprising instructionsthat when executed by a computing device having a touchscreen cause thecomputing device to perform operations comprising: detecting, by adevice having a touchscreen, a first gesture by a user on thetouchscreen while the device is in a sleep mode; classifying the firstgesture, by the device, as an intentional gesture or an accidentalgesture and either (i) maintaining the device in the sleep mode if thefirst gesture is classified as an accidental gesture, or (ii)determining, by the device, whether the first gesture matches one ormore confirmed gestures stored on the device if the first gesture isclassified as an intentional gesture; and, if the first gesture isclassified as an intentional gesture, either (i) requiring an additionaluser input to authenticate the user if the first gesture does not matchone or more confirmed gestures stored on the device, or (ii) recognizingthe user as authenticated and selecting and launching an applicationfrom a plurality of applications on the device according to the firstgesture, if the first gesture matches one or more confirmed gesturesstored on the device, without requiring any user input in addition tothe first gesture to authenticate the user or select and launch theapplication.
 19. The non-transitory computer storage medium of claim 18,wherein the operations further comprise: identifying the first gestureas a drawing of an alphanumeric character on the touchscreen, thealphanumeric character having an alphanumeric value.
 20. Thenon-transitory computer storage medium of claim 19, wherein theoperations further comprise: providing the alphanumeric value as aninput to the application.
 21. The non-transitory computer storage mediumof claim 18, wherein the operations further comprise: in accordance witha classification of the first gesture as an intentional gesture and adetermination that the first gesture matches one or more confirmedgestures stored on the device: determining, by the device, that thedevice is in a locked mode; and, without requiring any additional userinput, unlocking the device.
 22. The non-transitory computer storagemedium of claim 18, wherein the operations further comprise: identifyingthe first gesture as a drawing of a predefined shape on the touchscreen.23. The non-transitory computer storage medium of claim 18, wherein theoperations further comprise: in accordance with a classification of thefirst gesture as an intentional gesture and a determination that thefirst gesture does not match one or more confirmed gestures stored onthe device: presenting, to the user, a password-based authenticationmechanism; and, requiring the user to input a password.
 24. Thenon-transitory computer storage medium of claim 23, wherein theoperations further comprise: determining, by the device, that the firstgesture identifies an alphanumeric value or a predefined shape; and,automatically providing the alphanumeric value or the predefined shapeidentified by the first gesture as a first portion of an input to thepassword-based authentication mechanism.
 25. The non-transitory computerstorage medium of claim 24, wherein the operations further comprise:responsive to detecting an intentional second gesture: determining, bythe device, that the second gesture identifies a second alphanumericvalue or a second predefined shape on the touchscreen; and,automatically providing the second alphanumeric value or the secondpredefined shape as a second portion of the input to the password-basedauthentication mechanism.
 26. The non-transitory computer storage mediumof claim 25, wherein the operations further comprise: authenticating theuser in accordance with the first portion of the input and the secondportion of the input.
 27. The non-transitory computer storage medium ofclaim 18, wherein the operations further comprise: in accordance with aclassification of the first gesture as an intentional gesture and adetermination that the first gesture does not match one or moreconfirmed gestures stored on the device: determining that the firstgesture includes a fingerprint characteristic of the user; presenting,to the user, a fingerprint-based authentication mechanism; and,providing the fingerprint characteristic included in the first gestureas part of an input to the fingerprint-based authentication mechanism.28. The non-transitory computer storage medium of claim 18, wherein theoperations further comprise: in accordance with a classification of thefirst gesture as an intentional gesture and a determination that thefirst gesture does not match one or more confirmed gestures stored onthe device: maintaining the device in the sleep mode by: maintaining ablank screen on the touchscreen, and, maintaining one or more electroniccomponents of the device other than the touchscreen in the sleep mode.29. The non-transitory computer storage medium of claim 18, wherein theoperations further comprise: while detecting the first gesture on thetouchscreen while the device is in a sleep mode, displaying a visual aidtracing the first gesture on the touchscreen at a reduced powerconsumption level.
 30. The non-transitory computer storage medium ofclaim 18, wherein classifying the first gesture as an intentionalgesture or an accidental gesture is based at least in part on anorientation and an acceleration of the device when the first gestureoccurs and on a duration of the first gesture on the touchscreen. 31.The device of claim 17, wherein the operations further comprise:providing the alphanumeric value as an input to the application.
 32. Thedevice of claim 16, wherein the operations further comprise: inaccordance with a determination that the gesture is classified as anintentional gesture and the gesture fails to match one or more confirmedgestures stored on the device: presenting, to the user, a password-basedauthentication mechanism; and requiring the user to input a password.33. The device of claim 16, wherein the operations further comprise:collecting an intentional gesture from a user who has beenauthenticated; and identifying the intentional gesture as a confirmedgesture.
 34. The device of claim 16, wherein the operations furthercomprise: while detecting the gesture on the touchscreen while thedevice is in a sleep mode, displaying a visual aid tracing the gestureon the touchscreen at a reduced power consumption level.